#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <cstring>
#include <ctime>
#include <functional>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <typeinfo>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL -1

#define LOG(level, format, ...) do{\
    if(level < LOG_LEVEL) break;\
    time_t t = time(nullptr);\
    struct tm *tm = localtime(&t);\
    char log_buf[64];\
    strftime(log_buf, sizeof(log_buf) - 1, "%Y-%m-%d %H:%M:%S", tm);\
    fprintf(stdout, "[%p %s %s:%d] " format "\n", (void*)pthread_self(), log_buf, __FILE__, __LINE__, ##__VA_ARGS__);\
}while(0)

#define LOG_INFO(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define LOG_DEBUG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define LOG_ERROR(format, ...) LOG(ERR, format, ##__VA_ARGS__)


class Buffer{
private:
    // 注意: 这里的起始地址：_buffer.data() 或者 &*_buffer.begin() 都可以
    char *Begin(){return &*_buffer.begin();}

    // 读写数据
    void ReadData(void *data, uint64_t len) {
        assert(len <= ReadableSize());
        std::copy(GetReadPos(), GetReadPos() + len, (char*)data);
        // MoveReadOffset(len);
    }
    void WriteData(const void *data, uint64_t len) {
        // 1. 确保可写空间足够 2. 拷贝数据
        if(len <= 0) return ;
        EnsureWriteSpace(len); 
        const char *d = static_cast<const char *>(data);
        std::copy(d, d + len, GetWritePos()); // 把 data 复制到 缓冲区
        // MoveWriteOffset(len);
    }

    void WriteBuffer(Buffer &buf) {
        return WriteData(buf.GetReadPos(), buf.ReadableSize());
    }

    void WriteString(const std::string &str) {
        return WriteData(str.c_str(), str.size());
    }

public:
    Buffer(uint64_t size = 1024): _reader_idx(0), _writer_idx(0){
        _buffer.resize(size);
    }

    // 获取当前读写位置地址
    char *GetWritePos() {return Begin() + _writer_idx;}
    char *GetReadPos(){return Begin() + _reader_idx;}
    
    // 将读写位置向后移动指定长度
    void MoveReadOffset(uint64_t len){
        assert(len <= ReadableSize());
        _reader_idx += len;
    }
    void MoveWriteOffset(uint64_t len){
        assert(len <= BufferHeadSize() + BufferTailSize());
        _writer_idx += len;
    }

    
    // 获取一行数据
    std::string GetLine(){
        char *pos = FindCRLF();
        if (pos == nullptr) {
            return "";
        }
        uint64_t len = pos - GetReadPos() + 1; // 包括 \n
        std::string str = ReadAsStringAndPop(len);
        return str;
    }

    // 获取缓冲区末尾空闲空间大小 -- 写偏移之后的空闲空间    
    uint64_t BufferTailSize() {return _buffer.size() - _writer_idx;}
    // 获取缓冲区起始空闲空间大小 -- 读偏移之前的空闲空间
    uint64_t BufferHeadSize(){return _reader_idx;}

    // 获取可读数据大小
    uint64_t ReadableSize() {return _writer_idx - _reader_idx;}

    
    // 确保可写空间足够 (移动 / 扩容)
    void EnsureWriteSpace(uint64_t len) {
        // 1. 末尾空闲空间大小足够, 直接返回
        if(BufferTailSize() >= len) return;
        // 2. 先移动读偏移
        if (len <= BufferHeadSize() + BufferTailSize()) {
            // 3. 空闲空间足够, 数据移动到起始位置
            uint64_t readable_size = ReadableSize(); // 保存当前数据大小
            // std::memmove(_buffer.data(), _buffer.data() + _reader_idx, ReadableSize());
            std::copy(GetReadPos(), GetReadPos() + readable_size, Begin()); // 将可读数据保存到起始位置
            
            // 更新读写偏移
            _writer_idx = readable_size; 
            _reader_idx = 0;
        } else {
            // 4. 扩容
            uint64_t new_size = _buffer.size() * 2; // 避免持续扩容
            while (new_size < len) {
                new_size *= 2;
            }
            _buffer.resize(new_size);
        }
    }
    void WriteAndPush(const void *data, uint64_t len) {
        WriteData(data, len);
        MoveWriteOffset(len);
    }

    void WriteStringAndPush(const std::string &str) {
        WriteString(str);
        MoveWriteOffset(str.size());
    }

    void WriteBufferAndPush(Buffer &buf) {
        WriteBuffer(buf);
        MoveWriteOffset(buf.ReadableSize());
    }

    void ReadAndPop(void *buf, uint64_t len) {
        ReadData(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadAsString(uint64_t len){
        assert(len <= ReadableSize());
        std::string str;
        str.resize(len);
        ReadData(&str[0], len);
        return str;
    }

    std::string ReadAsStringAndPop(uint64_t len){
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    char *FindCRLF(){
        char *res = (char*)std::memchr(GetReadPos(), '\n', ReadableSize());
        return res;
    }

    std::string GetLineAndPop(){
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 9. 清空缓冲区   
    void clear(){
        _buffer.clear();
        _reader_idx = 0;
        _writer_idx = 0;
    }

private:
    std::vector<char> _buffer; // 使用 vector 进行内存空间管理
    // 位置, 是一个相对偏移量, 而不是绝对地址
    uint64_t _reader_idx;  // 相对读偏移
    uint64_t _writer_idx; // 相对写偏移
};



// Socket 类
#define MAXLISTEN 1024
class Socket{
private:
    // 1.创建套接字
    bool Create(){
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(_sockfd < 0){
            LOG_ERROR("CREATE SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 2.绑定地址信息
    bool Bind(const std::string &ip, uint16_t port){
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        socklen_t len = sizeof(struct sockaddr_in);
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if(ret < 0){
            LOG_ERROR("BIND SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 3.监听
    bool Listen(int backlog = MAXLISTEN){
        int ret = listen(_sockfd, backlog);
        if(ret < 0){
            LOG_ERROR("LISTEN SOCKET ERROR");
            return false;
        }
        return true;
    }
    // 4.向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port){
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        socklen_t len = sizeof(struct sockaddr_in);
        int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
        if(ret < 0){
            LOG_ERROR("CONNECT SOCKET ERROR");
            return false;
        }
        return true;
    }
    
    
public:
    Socket():_sockfd(-1){}
    ~Socket(){Close();}
    Socket(int sockfd): _sockfd(sockfd){}
    // 避免拷贝问题
    Socket(const Socket&) = delete;
    Socket& operator=(const Socket&) = delete;

    int Fd() const {return _sockfd;}
    void ShutdownWrite() {::shutdown(_sockfd, SHUT_WR);}


    // 5.获取新连接
    int Accept(){
        int newfd = accept(_sockfd, nullptr, nullptr);
        if(newfd < 0){
            LOG_ERROR("ACCEPT SOCKET ERROR");
            return -1;
        }
        return newfd; // 返回新连接的套接字
    }

    // 6.接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0){
        ssize_t ret = recv(_sockfd, buf, len, flag);
        // < 0 出错
        // = 0 连接断开
        // > 0 接收成功
        if(ret <= 0){
            // EAGAIN | EWOULDBLOCK: 当前 socket 的非阻塞缓冲区没有数据了
            // EINTR: 当前 socket 的阻塞等待被信号中断
            // ECONNRESET: 连接重置
            // ENOTCONN: 套接字未连接
            // ETIMEDOUT: 接收超时
            if(errno == EAGAIN || errno == EINTR){
                return 0; // 表示: 这次发送没有发送成功, 需重试
            }
            LOG_ERROR("Recv SOCKET %s" , strerror(errno));
            return -1; // 其他错误
        }    
        return ret; // 实际接收长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len){
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
    }

    // 7.发送数据
    ssize_t Send(const void* buf, size_t len, int flag = 0){
        ssize_t ret = send(_sockfd, buf, len, flag);
        if(ret < 0){
            if(errno == EAGAIN || errno == EINTR){
                return 0; // 表示: 这次发送没有发送成功, 需重试
            }
            LOG_ERROR("SEND SOCKET %s" , strerror(errno));
            return -1; // 其他错误 
        }
        return ret;
    }
    ssize_t NonBlockSend(const void* buf, size_t len){
        if(len == 0) return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞
    }

    // 8.关闭套接字
    void Close(){
        if(_sockfd != -1){
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 9.设置套接字选项 -- 开启地址端口重用
    void ReuseAddr() {
        int opt = 1;
        // SO_REUSEADDR: 允许重用本地地址和端口
        // SO_REUSEPORT: 允许重用本地端口
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(opt));
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&opt, sizeof(opt));
    }

    // 10.设置套接字阻塞属性 -- 设置为非阻塞
    void NonBlock(){
        int flag = fcntl(_sockfd, F_GETFL, 0);
        if(flag == -1){
            LOG_ERROR("GET SOCKET FLAG ERROR");
            return;
        }
        int ret = fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
        if(ret < 0){
            LOG_ERROR("SET SOCKET NONBLOCK ERROR");
            return;
        }
    }

    // 9. 创建一个服务器连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool nonblock_flag = false){
        if(!Create()) return false;
        if(nonblock_flag) NonBlock(); // 设置非阻塞
        ReuseAddr(); // 设置地址端口重用

        if(!Bind(ip, port)) return false;
        if(!Listen()) return false;
        return true;
    }   
    // 10. 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip){
        // 1. 创建套接字 2. 连接服务器
        if(!Create()) return false;
        if(!Connect(ip, port)) return false;
        return true;
    }

private:
    int _sockfd;
};


class Poller;
class EventLoop;
class Channel{
public:
    using EventCallback = std::function<void()>; // 注意: 这里不能放在 private 中, 否则会报错
    // explicit Channel(Poller* poller, int fd):_fd(fd),_events(0),_revents(0),_poller(poller){} // 显式调用 
    explicit Channel(EventLoop *loop, int fd):_fd(fd), _events(0), _revents(0), _loop(loop) {} 

    ~Channel(){
        if (_fd != -1) {
            close(_fd);
            _fd = -1; // 避免重复关闭
        }
    }
    Channel(const Channel&) = delete;
    Channel& operator=(const Channel&) = delete;

    int Fd() const {return _fd;}
    uint32_t Events() const {return _events;}

    // 判断当前事件是否可读写
    bool ReadAble() const { return (_events & EPOLLIN);  }
    bool WriteAble() const { return (_events & EPOLLOUT);}
    
    // 设置回调函数
    void SetReadCallback(const EventCallback& cb) {_read_callback = cb;}
    void SetWriteCallback(const EventCallback& cb){_write_callback = cb;}
    void SetCloseCallback(const EventCallback& cb){_close_callback = cb;}
    void SetErrorCallback(const EventCallback& cb){_error_callback = cb;}
    void SetEventCallback(const EventCallback& cb){_event_callback = cb;}
    /* 监控事件开关 -- 进行事件监控连接后, 描述符就绪事件, 设置实际就绪事件*/
    void SetREvents(uint32_t events){ _revents = events;}
    

    /* 开启事件监控 */
    void EnableRead(){ _events |= EPOLLIN; Update();}
    void EnableWrite(){ _events |= EPOLLOUT; Update();}

    /* 关闭事件监控 */
    void DisableRead(){ _events &= ~EPOLLIN; Update();}
    void DisableWrite(){ _events &= ~EPOLLOUT; Update();} 
    void DisableAll(){_events = 0; Update();} // 关闭所有事件

    /* 后面调用 EventLoop 接口来移除事件监控 */
    void Remove(); // 移除事件
    void Update(); // 更新事件
    
    void HandleEvent(){ // 处理事件, 判断连接触发了什么事件  
        // 实际项目中, 连接断开并不会直接先断开, 还是看到是否有数据可读, 先读完数据或者发送出错再断开
        if((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)){
            // 不管任何事件, 都会调用的回调函数
            if(_event_callback) _event_callback();
            if(_read_callback) _read_callback();
        }
        else if(_revents & EPOLLOUT){
            // 不管任何事件, 都会调用的回调函数
            if(_event_callback) _event_callback(); 
            if(_write_callback) _write_callback();
        }
        else if(_revents & EPOLLERR){
            if(_error_callback) _error_callback();
        }
        else if(_revents & EPOLLHUP){
            if(_close_callback) _close_callback();
        }
        // if(_event_callback) _event_callback(); // 任意事件回调
    }
private:
    int _fd; // 事件对应的文件描述符
    uint32_t _events; // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    // Poller* _poller; // 事件循环
    EventLoop* _loop;

    EventCallback _read_callback;   // 读事件回调
    EventCallback _write_callback;  // 写事件回调
    EventCallback _close_callback;  // 关闭事件回调
    EventCallback _error_callback;  // 错误事件回调
    EventCallback _event_callback;  // 任意事件回调
};


#define MAX_EPOLLEREVENTS 1024
class Poller{
private:
    // 对 epoll 的之间操作
    void Update(Channel* channel, int op){
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
        int fd = channel->Fd();
        struct epoll_event event;
        event.data.fd = fd; // 事件对应的文件描述符
        event.events = channel->Events(); // 需要监控的事件
        int ret = epoll_ctl(_epfd, op, fd, &event);
        if(ret < 0){
            LOG_ERROR("EPOLL_CTL ERROR");
        }
        return ;
    }

    // 判断一个 Channel 是否已经添加了 事件监控
    bool HasChannel(Channel* channel){
        return _channels.find(channel->Fd()) != _channels.end();
    }

public:
    Poller(){
        // _epfd = epoll_create(MAX_EPOLLEREVENTS); // 这个已经过时
        _epfd = epoll_create1(EPOLL_CLOEXEC); // 创建 epoll 文件描述符
        if(_epfd < 0){
            LOG_ERROR("EPOLL_CREATE ERROR");
            abort(); // 退出程序
        }
    }

    Poller(const Poller&) = delete;
    Poller& operator=(const Poller&) = delete;

    // 添加 / 修改 监控事件
    void UpdateEvent(Channel* channel){
        bool ret = HasChannel(channel);
        if(!ret){
            // 不存在, 添加事件
            _channels.insert(std::make_pair(channel->Fd(), channel)); // 添加到映射表
            return Update(channel, EPOLL_CTL_ADD); 
        }
        return Update(channel, EPOLL_CTL_MOD); // 已经存在, 修改事件
    }

    void RemoveEvent(Channel* channel){
        auto it = _channels.find(channel->Fd());
        if(it != _channels.end()){
            _channels.erase(it); // 从映射表中删除
        }
        Update(channel, EPOLL_CTL_DEL); // 删除事件
    }

    // 开始监控, 返回活跃连接
    void Poll(std::vector<Channel*> *active){
        // int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _events, MAX_EPOLLEREVENTS, -1);
        if(nfds < 0){
            if(errno == EINTR){
                return; // 被信号中断
            }
            LOG_ERROR("EPOLL_WAIT ERROR: %s\n", strerror(errno));
            abort(); // 退出程序
        }
        // 遍历活跃连接
        for(int i = 0; i < nfds; ++i){ 
            int fd = _events[i].data.fd;
            auto it = _channels.find(fd);
            assert(it != _channels.end()); // 断言: 事件一定存在

            Channel* channel = it->second;
            channel->SetREvents(_events[i].events); // 设置当前事件
            active->push_back(channel); // 添加到活跃连接列表
        }
    }

private:
    int _epfd; // epoll 文件描述符
    struct epoll_event _events[MAX_EPOLLEREVENTS]; // epoll 事件数组
    std::unordered_map<int, Channel*> _channels; // fd -> Channel 映射表
};



using TaskFunc = std::function<void()>;
using ReleaserFunc = std::function<void()>;

// 定时器任务
class TimerTask{
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc& cb):
        _id(id),_timeout(delay),_cb(cb),_canceled(false)
    {}

    ~TimerTask() { 
        if (!_canceled) {
            // std::thread(_cb).detach(); // 不能异步执行回调
            _cb();
        }
        // if (!_canceled) _cb();  // 用这个的话 _cb 就会先执行, 否则后执行
        _release(); 
    }

    void SetRelease(const ReleaserFunc& release){_release = release;}
    void Cancel() {_canceled = true;} // 取消定时任务
    uint32_t DelayTime() const { return _timeout; }

private:
    uint64_t _id;           // 定时器任务 id
    uint32_t _timeout;      // 定时任务超时时间
    bool _canceled;         // 是否取消定时任务(true: 取消)
    TaskFunc _cb;           // 定时器对象要执行的定时任务
    ReleaserFunc _release;  // 用于删除 TimerWheel 中保存的定时器对象信息
};

// 定时器轮
class TimerWheel{
private:
    using WeakTask = std::weak_ptr<TimerTask>; // 辅助 shared_ptr 解决循环引用问题
    using PtrTask = std::shared_ptr<TimerTask>;
    const int capacity = 60; // 定时器轮的大小 -- 最大延迟时间

    void RemoveTimer(uint64_t id){
        auto it = _timers.find(id);
        if(it != _timers.end()){
            _timers.erase(it); // 删除定时器对象
        }
    }

    static int CreateTimerfd(){
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0) {
            LOG_ERROR("Create timerfd error");
            abort();
        }

        struct itimerspec itime;
        // 设置第一次超时间隔时间为 1 s
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;
    
        // 设置第一次超时后 每次超时时间间隔为 1 s
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, nullptr); // 设置定时器

        return timerfd;
    }

    int ReadTimerfd(){
        uint64_t times = 0;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        ssize_t ret = read(_timerfd, &times, sizeof(times));
        if (ret < 0) {
            LOG_ERROR("READ TIMERFD ERROR");
            abort(); // 退出程序
        }
        return times;
    }

    // 3. 执行定时任务 
    void RunTimerTask(){
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空当前 tick 的任务
    }

    void OnTime(){
        //根据实际超时的次数，执行对应的超时任务
        int times = ReadTimerfd(); // 读取定时器文件描述符, 触发事件
        for(int i = 0; i < times; ++i){
            RunTimerTask(); // 执行定时任务
        }
    }

    // 1. 添加定时任务
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc& cb){  
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        
        int pos = (_tick + delay) % _capacity; // 计算定时器任务在轮子上的位置
        _wheel[pos].push_back(pt); // 将定时器任务添加到轮子上
        _timers[id] = WeakTask(pt); // 不能用 shared_ptr, 否则永久有shared_ptr 来管理, 计数不归0         
    }   
    

    // 4. 刷新/延迟 定时任务
    void TimerRefreshInLoop(uint64_t id) {
        // 1, 通过保存定时器对象的 weak_ptr 来获取定时器对象 添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())  // 没找到定时任务, 无法刷新和延迟
            return;
        
        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr

        int delay = pt->DelayTime();
        
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    // 5. 取消定时任务
    void TimerCanceInLoop(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) return ;

        PtrTask pt = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        // 如果weak_ptr管理的对象已经被销毁（即引用计数为0），lock()会返回一个空的shared_ptr
        // 如果对象仍然存在，lock()会返回一个有效的shared_ptr，指向该对象

        if(pt) pt->Cancel(); // 取消定时任务
    }
    
    /*这个接口存在线程安全问题--这个接口实际上不能被外界使用者调用，只能在模块内，在对应的EventLoop线程内执行*/
    bool HasTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) return false;
        return true;
    }

public:
    friend class EventLoop; // 事件循环类

    TimerWheel(EventLoop *loop):_capacity(capacity),_tick(0),_wheel(_capacity),_loop(loop), _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this)); // 设置定时器可读事件回调函数
        _timer_channel->EnableRead(); // 启动读事件监控
    }

    // 1. 添加定时任务
    void AddTimer(uint64_t id, uint32_t delay, const TaskFunc& cb);
    // 2. 刷新/延迟 定时任务
    void RefreshTimer(uint64_t id);
    // 3. 取消定时任务
    void CancelTimer(uint64_t id);

private:
    int _tick; // 当前指针, 走到哪释放哪(相当于执行哪里任务)
    int _capacity; // 定时器轮的大小 -- 最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel; // 定时器轮
    std::unordered_map<uint64_t, WeakTask> _timers; // 定时器任务 id 和定时器对象的映射关系

    EventLoop* _loop; // 事件循环
    int _timerfd; // 定时器文件描述符 -- 可读事件回调 读取计数器, 执行定时任务
    std::unique_ptr<Channel> _timer_channel; // 定时器通道
};

class EventLoop {
    private:
        using Functor = std::function<void()>;
        std::thread::id _thread_id;//线程ID
        int _event_fd;//eventfd唤醒IO事件监控有可能导致的阻塞
        std::unique_ptr<Channel> _event_channel;
        Poller _poller;//进行所有描述符的事件监控
        std::vector<Functor> _tasks;//任务池
        std::mutex _mutex;//实现任务池操作的线程安全
        TimerWheel _timer_wheel;//定时器模块
    public:
        //执行任务池中的所有任务
        void RunAllTask() {
            std::vector<Functor> functor;
            {
                std::unique_lock<std::mutex> _lock(_mutex);
                _tasks.swap(functor);
            }
            for (auto &f : functor) {
                f();
            }
            return ;
        }
        static int CreateEventFd() {
            int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
            if (efd < 0) {
                LOG_ERROR("CREATE EVENTFD FAILED!!");
                abort();//让程序异常退出
            }
            return efd;
        }
        void ReadEventfd() {
            uint64_t res = 0;
            int ret = read(_event_fd, &res, sizeof(res));
            if (ret < 0) {
                //EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
                if (errno == EINTR || errno == EAGAIN) {
                    return;
                }
                LOG_ERROR("READ EVENTFD FAILED!");
                abort();
            }
            return ;
        }
        void WeakUpEventFd() {
            uint64_t val = 1;
            int ret = write(_event_fd, &val, sizeof(val));
            if (ret < 0) {
                if (errno == EINTR) {
                    return;
                }
                LOG_ERROR("READ EVENTFD FAILED!");
                abort();
            }
            return ;
        }
    public:
        EventLoop():_thread_id(std::this_thread::get_id()), 
                    _event_fd(CreateEventFd()), 
                    _event_channel(new Channel(this, _event_fd)),
                    _timer_wheel(this) {
            //给eventfd添加可读事件回调函数，读取eventfd事件通知次数
            _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
            //启动eventfd的读事件监控
            _event_channel->EnableRead();
        }
        //三步走--事件监控-》就绪事件处理-》执行任务
        void Start() {
            while(1) {
                //1. 事件监控， 
                std::vector<Channel *> actives;
                _poller.Poll(&actives);
                //2. 事件处理。 
                for (auto &channel : actives) {
                    channel->HandleEvent();
                }
                //3. 执行任务
                RunAllTask();
            }
        }
        //用于判断当前线程是否是EventLoop对应的线程；
        bool IsInLoop() {
            return (_thread_id == std::this_thread::get_id());
        }
        void AssertInLoop() {
            assert(_thread_id == std::this_thread::get_id());
        }
        //判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列。
        void RunInLoop(const Functor &cb) {
            if (IsInLoop()) {
                return cb();
            }
            return QueueInLoop(cb);
        }
        //将操作压入任务池
        void QueueInLoop(const Functor &cb) {
            {
                std::unique_lock<std::mutex> _lock(_mutex);
                _tasks.push_back(cb);
            }
            //唤醒有可能因为没有事件就绪，而导致的epoll阻塞；
            //其实就是给eventfd写入一个数据，eventfd就会触发可读事件
            WeakUpEventFd();
        }
        //添加/修改描述符的事件监控
        void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
        //移除描述符的监控
        void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
        void AddTimer(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.AddTimer(id, delay, cb); }
        void RefreshTimer(uint64_t id) { return _timer_wheel.RefreshTimer(id); }
        void CancelTimer(uint64_t id) { return _timer_wheel.CancelTimer(id); }
        bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};


class LoopThread{
private:
// 实例化 EventLoop 对象, 唤醒 _cond 上有可能阻塞的线程, 并且开始运行 EventLoop 模块的功能
    void ThreadEntry(){
        EventLoop loop; // 实例化 EventLoop 对象
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _loop = &loop; // 保存 EventLoop 对象指针, 不创建一个新的, 是希望 LoopThread 来管理其生命周期
            _cond.notify_all(); // 唤醒阻塞的线程
        }
        loop.Start(); // 循环运行
    }

public:
    // 创建线程, 设定线程入口函数
    LoopThread(): _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)){}

    // 返回 EventLoop 对象指针
    EventLoop* Loop() { 
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _cond.wait(_lock, [&](){return _loop != nullptr;}); // loop 如果为 nullptr 则等待
            loop = _loop; // 获取 EventLoop 对象指针
        }
        return loop;
    }

private:
    EventLoop* _loop; // EventLoop 指针变量, 这个对象需要在线程内实例化
    std::thread _thread; // EventLoop 对应的线程对象

    // 用于实现 _loop 获取的同步关系, 避免线程创建但是 _loop 还没有初始化的情况
    std::mutex _mutex; // 互斥锁
    std::condition_variable _cond; // 条件变量
};


class LoopThreadPool{
public:
    LoopThreadPool(EventLoop *baseloop): _thread_cnt(0), _next_idx(0), _baseloop(baseloop){}

    // 设置线程数量
    void SetThreadCount(int cnt){
        _thread_cnt = cnt;
    }

    // 创建所有的从属线程
    void CreateThreads(){
        if(_thread_cnt > 0){
            _threads.resize(_thread_cnt); // 也可以用 reserve
            _loops.resize(_thread_cnt);
            for(int i = 0; i < _thread_cnt; ++i){
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->Loop(); // 获取 EventLoop 对象指针
            }
        }
        return ;
    }

    // 获取下一个 Loop
    EventLoop* NextLoop(){
        if(_thread_cnt == 0){return _baseloop;}
        _next_idx = (_next_idx + 1) % _thread_cnt; // 轮询分配线程
        return _loops[_next_idx];
    }
    
private:    
    int _thread_cnt;                  // 从属线程数量
    int _next_idx;                 // 下一个待分配的 EventLoop 索引
    EventLoop* _baseloop;               // 主 EventLoop, 运行在主线程, 若从属线程为 0, 则所有操作都在 baseLoop 上进行
    std::vector<LoopThread*> _threads;   // 保存所有的 LoopThread 对象
    std::vector<EventLoop*> _loops;     // 从属线程数量 大于 0, 则从 _loops 中取出 EventLoop 进行操作, 否则操作 _baseloop
};


class Any{
private:
    class holder {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };
    template<class T>
    class placeholder: public holder {
    public:
        placeholder(const T &val): _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info& type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }
    public:
        T _val;
    };
    holder *_content;

public:
    Any():_content(NULL) {}
    template<class T>
    Any(const T &val):_content(new placeholder<T>(val)) {}
    Any(const Any &other):_content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }

    Any &swap(Any &other) {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template<class T>
    T *get() {
        //想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T>*)_content)->_val;
    }
    //赋值运算符的重载函数
    template<class T>
    Any& operator=(const T &val) {
        //为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any& operator=(const Any &other) {
        Any(other).swap(*this);
        return *this;
    }
};


class Connection;
// DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
typedef enum { DISCONNECTED = 0, CONNECTING, CONNECTED, DISCONNECTING}ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection: public std::enable_shared_from_this<Connection>{
private:  
    // 这四个回调函数, 是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）
    // 换句话说, 这几个回调都是组件使用者使用的
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;

    /* 五个 Channel 的事件回调函数 */
    // 描述符可读事件后调用的函数, 接收 socket 数据放到接收缓冲区中, 然后调用 _message_callback
    void HandleRead(){
        char buf[65536];
        int ret = _socket.NonBlockRecv(buf, sizeof(buf) - 1); // 获取非阻塞下的实际接收长度
        if(ret < 0){
            return ShutdownInLoop();
        }
        // 这里的等于 0 表示的是没有读取到数据, 而不是连接断开, 连接断开返回的是 -1
        _in_buffer.WriteAndPush(buf, ret); // 将数据放入输入缓冲区
        if(_in_buffer.ReadableSize() > 0){
            // 通常用于在已有的 std::shared_ptr 管理的对象中创建新的 std::shared_ptr，而不会增加引用计数的错误
            // 这个函数确保了在对象已经被 std::shared_ptr 管理的情况下，可以通过该对象获取到管理它的 std::shared_ptr
            return _message_callback(shared_from_this(), &_in_buffer); // 调用消息回调函数
        }
    }

    // 描述符可写事件触发后调用的函数, 将发送缓冲区中的数据进行发送
    void HandleWrite(){
        int ret = _socket.NonBlockSend(_out_buffer.GetReadPos(), _out_buffer.ReadableSize()); // 发送数据
        if(ret < 0){
            // 先判断缓冲区是否有数据可读
            if(_in_buffer.ReadableSize() > 0){
                return _message_callback(shared_from_this(), &_in_buffer); // 调用消息回调函数
            }
            return Release(); // 这个时候就是实际的关闭连接操作
        }
        _out_buffer.MoveReadOffset(ret); // 移动读指针
        if(_out_buffer.ReadableSize() == 0){
            _channel.DisableWrite(); // 发送缓冲区已清空, 禁止写事件监控
            // 如果当前是连接关闭状态, 如果有数据则发送完数据再释放连接
            if(_status == DISCONNECTING){
                return Release();
            }
        }
        return;
    }
    // 描述符触发挂断事件
    void HandleClose(){
        /*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
        if(_in_buffer.ReadableSize() > 0){
            _message_callback(shared_from_this(), &_in_buffer); // 调用消息回调函数
        }
        return Release(); // 关闭连接

    }
    // 描述符触发错误事件
    void HandleError(){
        return HandleClose();
    } 
    // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
    void HandleEvent(){
        if(_enable_inactive_release == true) _loop->RefreshTimer(_conn_id);
        if(_event_callback) _event_callback(shared_from_this()); // 调用任意事件回调函数)
    }

// 连接获取之后, 所处状态下进行的各种设置（给 Channel 设置事件回调, 启动读监控）
    void EstablishInLoop(){
        // 1. 修改连接状态  2. 启动读事件监控 3. 调用回调函数
        assert(_status == CONNECTING); // 当前的状态必须一定是上层的半连接状态(只有这个函数完成, 才真正处于 CONNECTED 状态)
        _status = CONNECTED; //当前函数执行完毕，则连接进入已完成连接状态

        // 原因: 一旦启动读事件监控就有可能触发读事件, 如果这个时候启动了非活跃连接销毁
        _channel.EnableRead(); // 启动读事件监控
        if(_connected_callback) _connected_callback(shared_from_this()); // 调用连接建立成功的回调函数
    }
    // 这个接口才是实际的释放接口
    void ReleaseInLoop(){
        // 1. 修改连接状态
        _status = DISCONNECTED;
        // 2. 移除连接的 Channel 事件监控
        _channel.Remove();
        // 3. 关闭读写事件监控 
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务, 则取消任务
        if(_loop->HasTimer(_conn_id)) _loop->CancelTimer(_conn_id);
        // 5. 调用关闭回调函数
        if(_closed_callback) _closed_callback(shared_from_this());
        if(_server_closed_callback) _server_closed_callback(shared_from_this()); 
    }

    // 这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
    void SendInLoop(Buffer &buf){
        if(_status == DISCONNECTED) return;
        _out_buffer.WriteBufferAndPush(buf);
        // 启动写事件监控
        if(!_channel.WriteAble()) _channel.EnableWrite(); 
    }
    // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
    void ShutdownInLoop() {
        _status = DISCONNECTING;// 设置连接为半关闭状态
        if (_in_buffer.ReadableSize() > 0) {
            if (_message_callback) _message_callback(shared_from_this(), &_in_buffer);
        }
        //要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
        if (_out_buffer.ReadableSize() > 0) {
            if (_channel.WriteAble() == false) {
                _channel.EnableWrite();
            }
        }
        if (_out_buffer.ReadableSize() == 0) {
            Release();
        }
    }
    void ShutdownWriteInLoop() {
        if (_status == DISCONNECTED || _status == DISCONNECTING) {
            return; // 已关闭或正在关闭，直接返回
        }

        // 标记为写端关闭（可自定义状态或使用已有状态）
        // 注意：这里不改变 _status，因为连接仍可读

        // 如果输出缓冲区还有数据，等待发送完成后再关闭写端
        if (_out_buffer.ReadableSize() > 0) {
            // 启动写事件监控，确保数据发送完成
            if (!_channel.WriteAble()) {
                _channel.EnableWrite();
            }
        } else {
            // 如果没有待发送数据，直接关闭写端
            _socket.ShutdownWrite();
        }
    }

    // 启动非活跃连接超时释放规则(sec: 延迟时间)
    void EnableInactiveReleaseInLoop(int sec){
        // 1. 设置判断标志 
        _enable_inactive_release = true;
        // 2. 如果当前定时销毁任务已存在, 则刷新延迟即可
        if(_loop->HasTimer(_conn_id)) return _loop->RefreshTimer(_conn_id);
        // 3. 不存在则新增定时销毁任务
        _loop->AddTimer(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    
    // 取消非活跃任务的超时销毁
    void CancelInactiveReleaseInLoop(){
        _enable_inactive_release = false;
        if(_loop->HasTimer(_conn_id)) _loop->CancelTimer(_conn_id);
    }

    // 切换协议, 重置上下文以及阶段性处理函数
    void UpgradeInLoop(const Any &context, 
        const ConnectedCallback &conn, 
        const MessageCallback &msg, 
        const ClosedCallback &closed, 
        const AnyEventCallback &event)
    {
        
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd):
        _conn_id(conn_id),
        _sockfd(sockfd),
        _enable_inactive_release(false),
        _loop(loop),
        _status(CONNECTING),
        _socket(sockfd),
        _channel(loop, sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
    }

    ~Connection(){LOG_ERROR("RELEASE CONNECTION: %p", this);}

    int Fd() const {return _sockfd;}
    int Id() const {return _conn_id;}
    bool Connected(){return _status == CONNECTED;} // 判断状态是否处于连接状态

    // 设置上下文 -- 连接建立完成时调用
    void SetContext(const Any &context){_context = context;}
    Any *GetContext() { return &_context; } // 获取的上下文(指针), 保证每次访问是同一个上下文
    
    void SetConnectedCallback(const ConnectedCallback& cb){_connected_callback = cb;}
    void SetMessageCallback(const MessageCallback& cb){_message_callback = cb;}
    void SetClosedCallback(const ConnectedCallback& cb){_closed_callback = cb;}
    void SetAnyEventCallback(const ConnectedCallback& cb){_event_callback = cb;}
    void SetSrvClosedCallback(const ClosedCallback& cb){_server_closed_callback = cb;}

    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established(){_loop->RunInLoop(std::bind(&Connection::EstablishInLoop, this));}
    // 发送数据, 将数据放到发送缓冲区, 启动写事件监控
    void Send(const char *data, size_t len){
        // 注意: 外界传入的 data, 可能是个临时空间, 不能直接使用, 需要进行一次拷贝(构造一个临时对象, 就不需要担心被释放的问题了)
        // 因为当前只是把发送操作压入了任务池, 有可能没有被立即执行
        // 因此可能执行的时候, data 指向的空间已经被释放了
        // _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, data, len)); // 错误的写法
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }

    // 提供给组件使用者的关闭接口 -- 并不实际关闭, 需要判断是否有数据待处理
    void Shutdown(){_loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));}
    
    void ShutdownWrite() {
        _loop->RunInLoop(std::bind(&Connection::ShutdownWriteInLoop, this));
    }

    // 释放连接, 关闭连接, 并从管理器中移除连接信息, 启动非活跃销毁, 并定义多长时间就是非活跃, 添加定时任务
    void Release(){_loop->RunInLoop(std::bind(&Connection::ReleaseInLoop, this));}

    // 启动非活跃销毁, 并定义多长时间就是非活跃, 添加定时任务
    void EnableInactiveRelease(int sec){_loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));}
    // 取消非活跃销毁
    void CancelInactiveRelease(int sec){_loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));}

    // 切换协议, 重置上下文以及阶段性处理函数
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    } 

private:
    uint64_t _conn_id;  // 连接 ID, 便于连接的管理和查找
    // uint64_t _timer_id; // 定时器ID
    int _sockfd;        // 连接关联的文件描述符
    bool _enable_inactive_release;  // 连接是否启动非活跃销毁的判断标志，默认为false
    EventLoop *_loop;   // 连接所关联的一个EventLoop
    ConnStatu _status;  // 连接状态
    Socket _socket;     // 连接的 Socket 对象
    Channel _channel;   // 连接的 Channel 对象
    Buffer _in_buffer;  // 输入缓冲区 -- 存放从 socket 中读取到的数据
    Buffer _out_buffer; // 输出缓冲区 -- 存放要发送对端的数据
    Any _context;       // 请求的接收处理上下文对象

    // 组件内的连接关闭回调 --- 组件内设置的
    ConnectedCallback _connected_callback; // 连接建立成功的回调函数
    MessageCallback _message_callback;     // 连接接收数据的回调函数
    ClosedCallback _closed_callback;    
    AnyEventCallback _event_callback;
    
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;
};

class Acceptor{
private:   
    using AcceptCallback = std::function<void(int)>;

    // 监听套接字读事件回调处理函数 -- 获取新连接, 调用 _accept_callback 函数进行新连接处理
    void HandleRead(){
        int newfd = _listen_socket.Accept();
        if(newfd < 0) return;
        if(_accept_callback) _accept_callback(newfd); // 调用新连接的回调函数
    }
    int CreateServer(int port){
        bool ret = _listen_socket.CreateServer(port);
        assert(ret == true);
        return _listen_socket.Fd();
    }

public:
    // 注意: 这里不能把启动读事件监控放到构造函数中, 必须设置回调函数后, 再去启动
    // 否则有可能造成启动监控后, 立即有事件, 处理的时候回调函数还未设置, 新连接得不到处理, 且资源泄漏
    Acceptor(EventLoop* loop, int port): _listen_socket(CreateServer(port)), _loop(loop), _channel(loop, _listen_socket.Fd()){
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
    }
    void SetAcceptCallback(const AcceptCallback &cb){_accept_callback = cb;}
    // 启动监听套接字的监听, 并设置监听套接字的读事件回调函数
    void Listen(){_channel.EnableRead();}

private:
    Socket _listen_socket; // 监听套接字
    EventLoop *_loop;      // 所属的 EventLoop
    Channel _channel;      // 监听套接字对应的 Channel
    AcceptCallback _accept_callback; // 监听套接字的回调函数
};


class TcpServer{
private:    
    using ConnectedCallback = std::function<void(const PtrConnection&)>;
    using MessageCallback = std::function<void(const PtrConnection&, Buffer*)>;
    using ClosedCallback = std::function<void(const PtrConnection&)>;
    using AnyEventCallback = std::function<void(const PtrConnection&)>;
    using Functor = std::function<void()>;

    void RunAfterInLoop(const Functor& task, int delay){
        _next_id++;
        _baseloop.AddTimer(_next_id, delay, task);
    }

    // 为新连接构造一个 Connection 对象, 并管理起来
    void NewConnection(int fd){
         _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release) conn->EnableInactiveRelease(_timeout);//启动非活跃超时销毁
        
        conn->Established(); // 连接建立就绪, 启动读写事件监控, 调用连接建立成功的回调函数
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const PtrConnection& conn){
        int id = conn->Id();
        auto it = _conns.find(id);
        if(it == _conns.end()) return ;
        _conns.erase(it); // 从管理的连接列表中移除连接信息
    }

    // 从管理的 Connection 对象中移除连接信息
    void RemoveConnection(const PtrConnection& conn){
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }


public:
    TcpServer(int port): 
        _port(port), 
        _next_id(0), 
        _timeout(0), 
        _enable_inactive_release(false), 
        _acceptor(&_baseloop, port),
        _pool(&_baseloop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen();
    }

    // 1. 设置从属线程池数量
    void SetThreadCount(int cnt){_pool.SetThreadCount(cnt);}
    // 2. 设置各种回调函数
    void SetConnectedCallback(const ConnectedCallback& cb){_connected_callback = cb;}
    void SetMessageCallback(const MessageCallback& cb){_message_callback = cb;}
    void SetClosedCallback(const ConnectedCallback& cb){_closed_callback = cb;}
    void SetAnyEventCallback(const ConnectedCallback& cb){_event_callback = cb;}

    // 3. 是否启动非活跃连接超时销毁功能 
    void EnableInactiveRelease(int timeout){_enable_inactive_release = true; _timeout = timeout;}

    // 4. 添加定时功能 
    void RunAfter(const Functor& task, uint32_t delay){
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }

    // 5. 启动服务器
    void Start(){_pool.CreateThreads(); _baseloop.Start();}
private:
    uint64_t _next_id;      // 连接 ID 自增
    int _port;              // 监听端口
    int _timeout;           // 超时时间, 单位: 秒, 处理非活跃连接
    bool _enable_inactive_release; // 非活跃连接是否启动超时销毁功能的标志, 默认为 false
    EventLoop _baseloop;   // 主线程 EventLoop 对象, 负责监听事件处理
    Acceptor _acceptor;     // 监听套接字的管理对象
    LoopThreadPool _pool;   // 这是从属 EventLoop 线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 管理所有连接对应的 shared_ptr 对象

    // 组件内的连接关闭回调 --- 组件内设置的
    ConnectedCallback _connected_callback; // 连接建立成功的回调函数
    MessageCallback _message_callback;     // 连接接收数据的回调函数
    ClosedCallback _closed_callback;    
    AnyEventCallback _event_callback;
    
};

void Channel::Remove(){return _loop->RemoveEvent(this); } // 移除事件
void Channel::Update(){return _loop->UpdateEvent(this);} // 更新事件

void TimerWheel::AddTimer(uint64_t id, uint32_t delay, const TaskFunc& cb){
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb)); // 添加定时任务
}
// 2. 刷新/延迟 定时任务
void TimerWheel::RefreshTimer(uint64_t id){
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id)); // 添加定时任务
}
// 3. 取消定时任务
void TimerWheel::CancelTimer(uint64_t id) {
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCanceInLoop, this, id)); // 添加定时任务
}


class NetWork{
public:
    NetWork(){
        LOG_INFO("SIGPIPE is ignored");
        signal(SIGPIPE, SIG_IGN); // 忽略 SIGPIPE 信号, 防止程序崩溃
    }
};

static NetWork network; // 网络管理对象

#endif


